#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "utils.h"
#include "base.h"
#include "parent.h"
#include "child.h"

#if 1
static void valid_test(void)
{
	int val;
	base_s base;
	parent_s parent;
	child_s child;

	debug("=====类对象构造=====\n");
	base_ctor(&base);
	parent_ctor(&parent);
	child_ctor(&child);

	base_print(&base);
	parent_print(&parent);
	child_print(&child);

	debug("=====类方法处理类对象，set=====\n");
	base_set_val(&base, 100);
	parent_set_val(&parent, 55);
	child_set_val(&child, 303);

	base_print(&base);
	parent_print(&parent);
	child_print(&child);

	debug("=====类方法处理类对象，get=====\n");
	val = base_get_val(&base);
	debug("val=%d\n", val);
	val = parent_get_val(&parent);
	debug("val=%d\n", val);
	val = child_get_val(&child);
	debug("val=%d\n", val);

	debug("=====父类方法处理子类对象，set=====\n");
	base_set_val(&parent, 121);
	base_set_val(&child, 256);
	parent_set_val(&child, 888);

	base_print(&base);
	parent_print(&parent);
	child_print(&child);

	debug("=====父类方法处理子类对象，get=====\n");
	val = base_get_val(&parent);
	debug("val=%d\n", val);
	val = base_get_val(&child);
	debug("val=%d\n", val);
	val = parent_get_val(&child);
	debug("val=%d\n", val);

  	debug("=====类对象析构=====\n");
	base_dtor(&base);
	parent_dtor(&parent);
	child_dtor(&child);
	debug("析构完成\n");
}

static void invalid_test(void)
{
	int t;

	debug("=====错误类型测试=====\n");
	base_print(&t);
	parent_print(&t);
	child_print(&t);
}

static void invalid_cmethod_test(void)
{
	base_s base;
	parent_s parent;
	child_s child;

	base_ctor(&base);
	parent_ctor(&parent);
	child_ctor(&child);

	debug("=====子类方法处理父类对象，set=====\n");
	child_set_val(&base, 777777);
	child_set_val(&parent, 123456);
	parent_set_val(&base, 1100);

	base_print(&base);
	parent_print(&parent);
	child_print(&child);

	debug("=====子类方法处理父类对象，get=====\n");
	child_get_val(&base);
	child_get_val(&parent);
	parent_get_val(&base);

	base_dtor(&base);
	parent_dtor(&parent);
	child_dtor(&child);
}
#endif

static void valid_single_test(void)
{
	base_s base;

	debug("=====单个对象测试=====\n");
	base_ctor(&base);
	base_print(&base);
	base_dtor(&base);
}

int main(int argc, char **argv)
{
	int flag = 0;

	if (argc > 1) flag = atoi(argv[1]);

    valid_test();
	switch (flag) {
		case 0: invalid_test(); break;
		case 1: invalid_cmethod_test(); break;
		default: valid_single_test(); break;
	}
    return 0;
}
